home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / media / videobuf-core.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  7.4 KB  |  248 lines
  1. /*
  2.  * generic helper functions for handling video4linux capture buffers
  3.  *
  4.  * (c) 2007 Mauro Carvalho Chehab, <mchehab@infradead.org>
  5.  *
  6.  * Highly based on video-buf written originally by:
  7.  * (c) 2001,02 Gerd Knorr <kraxel@bytesex.org>
  8.  * (c) 2006 Mauro Carvalho Chehab, <mchehab@infradead.org>
  9.  * (c) 2006 Ted Walther and John Sokol
  10.  *
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2
  14.  */
  15.  
  16. #ifndef _VIDEOBUF_CORE_H
  17. #define _VIDEOBUF_CORE_H
  18.  
  19. #include <linux/poll.h>
  20. #ifdef CONFIG_VIDEO_V4L1_COMPAT
  21. #include <linux/videodev.h>
  22. #endif
  23. #include <linux/videodev2.h>
  24.  
  25. #define UNSET (-1U)
  26.  
  27.  
  28. struct videobuf_buffer;
  29. struct videobuf_queue;
  30.  
  31. /* --------------------------------------------------------------------- */
  32.  
  33. /*
  34.  * A small set of helper functions to manage video4linux buffers.
  35.  *
  36.  * struct videobuf_buffer holds the data structures used by the helper
  37.  * functions, additionally some commonly used fields for v4l buffers
  38.  * (width, height, lists, waitqueue) are in there.  That struct should
  39.  * be used as first element in the drivers buffer struct.
  40.  *
  41.  * about the mmap helpers (videobuf_mmap_*):
  42.  *
  43.  * The mmaper function allows to map any subset of contingous buffers.
  44.  * This includes one mmap() call for all buffers (which the original
  45.  * video4linux API uses) as well as one mmap() for every single buffer
  46.  * (which v4l2 uses).
  47.  *
  48.  * If there is a valid mapping for a buffer, buffer->baddr/bsize holds
  49.  * userspace address + size which can be feeded into the
  50.  * videobuf_dma_init_user function listed above.
  51.  *
  52.  */
  53.  
  54. struct videobuf_mapping {
  55.     unsigned int count;
  56.     unsigned long start;
  57.     unsigned long end;
  58.     struct videobuf_queue *q;
  59. };
  60.  
  61. enum videobuf_state {
  62.     VIDEOBUF_NEEDS_INIT = 0,
  63.     VIDEOBUF_PREPARED   = 1,
  64.     VIDEOBUF_QUEUED     = 2,
  65.     VIDEOBUF_ACTIVE     = 3,
  66.     VIDEOBUF_DONE       = 4,
  67.     VIDEOBUF_ERROR      = 5,
  68.     VIDEOBUF_IDLE       = 6,
  69. };
  70.  
  71. struct videobuf_buffer {
  72.     unsigned int            i;
  73.     u32                     magic;
  74.  
  75.     /* info about the buffer */
  76.     unsigned int            width;
  77.     unsigned int            height;
  78.     unsigned int            bytesperline; /* use only if != 0 */
  79.     unsigned long           size;
  80.     unsigned int            input;
  81.     enum v4l2_field         field;
  82.     enum videobuf_state     state;
  83.     struct list_head        stream;  /* QBUF/DQBUF list */
  84.  
  85.     /* touched by irq handler */
  86.     struct list_head        queue;
  87.     wait_queue_head_t       done;
  88.     unsigned int            field_count;
  89.     struct timeval          ts;
  90.  
  91.     /* Memory type */
  92.     enum v4l2_memory        memory;
  93.  
  94.     /* buffer size */
  95.     size_t                  bsize;
  96.  
  97.     /* buffer offset (mmap + overlay) */
  98.     size_t                  boff;
  99.  
  100.     /* buffer addr (userland ptr!) */
  101.     unsigned long           baddr;
  102.  
  103.     /* for mmap'ed buffers */
  104.     struct videobuf_mapping *map;
  105.  
  106.     /* Private pointer to allow specific methods to store their data */
  107.     int            privsize;
  108.     void                    *priv;
  109. };
  110.  
  111. struct videobuf_queue_ops {
  112.     int (*buf_setup)(struct videobuf_queue *q,
  113.              unsigned int *count, unsigned int *size);
  114.     int (*buf_prepare)(struct videobuf_queue *q,
  115.                struct videobuf_buffer *vb,
  116.                enum v4l2_field field);
  117.     void (*buf_queue)(struct videobuf_queue *q,
  118.               struct videobuf_buffer *vb);
  119.     void (*buf_release)(struct videobuf_queue *q,
  120.                 struct videobuf_buffer *vb);
  121. };
  122.  
  123. #define MAGIC_QTYPE_OPS    0x12261003
  124.  
  125. /* Helper operations - device type dependent */
  126. struct videobuf_qtype_ops {
  127.     u32                     magic;
  128.  
  129.     void *(*alloc)        (size_t size);
  130.     void *(*vmalloc)    (struct videobuf_buffer *buf);
  131.     int (*iolock)        (struct videobuf_queue* q,
  132.                  struct videobuf_buffer *vb,
  133.                  struct v4l2_framebuffer *fbuf);
  134.     int (*mmap)        (struct videobuf_queue *q,
  135.                  unsigned int *count,
  136.                  unsigned int *size,
  137.                  enum v4l2_memory memory);
  138.     int (*sync)        (struct videobuf_queue* q,
  139.                  struct videobuf_buffer *buf);
  140.     int (*video_copy_to_user)(struct videobuf_queue *q,
  141.                  char __user *data,
  142.                  size_t count,
  143.                  int nonblocking);
  144.     int (*copy_stream)    (struct videobuf_queue *q,
  145.                  char __user *data,
  146.                  size_t count,
  147.                  size_t pos,
  148.                  int vbihack,
  149.                  int nonblocking);
  150.     int (*mmap_free)    (struct videobuf_queue *q);
  151.     int (*mmap_mapper)    (struct videobuf_queue *q,
  152.                 struct vm_area_struct *vma);
  153. };
  154.  
  155. struct videobuf_queue {
  156.     struct mutex               vb_lock;
  157.     spinlock_t                 *irqlock;
  158.     struct device           *dev;
  159.  
  160.     wait_queue_head_t       wait; /* wait if queue is empty */
  161.  
  162.     enum v4l2_buf_type         type;
  163.     unsigned int               inputs; /* for V4L2_BUF_FLAG_INPUT */
  164.     unsigned int               msize;
  165.     enum v4l2_field            field;
  166.     enum v4l2_field            last;   /* for field=V4L2_FIELD_ALTERNATE */
  167.     struct videobuf_buffer     *bufs[VIDEO_MAX_FRAME];
  168.     struct videobuf_queue_ops  *ops;
  169.     struct videobuf_qtype_ops  *int_ops;
  170.  
  171.     unsigned int               streaming:1;
  172.     unsigned int               reading:1;
  173.     unsigned int           is_mmapped:1;
  174.  
  175.     /* capture via mmap() + ioctl(QBUF/DQBUF) */
  176.     struct list_head           stream;
  177.  
  178.     /* capture via read() */
  179.     unsigned int               read_off;
  180.     struct videobuf_buffer     *read_buf;
  181.  
  182.     /* driver private data */
  183.     void                       *priv_data;
  184. };
  185.  
  186. int videobuf_waiton(struct videobuf_buffer *vb, int non_blocking, int intr);
  187. int videobuf_iolock(struct videobuf_queue* q, struct videobuf_buffer *vb,
  188.         struct v4l2_framebuffer *fbuf);
  189.  
  190. void *videobuf_alloc(struct videobuf_queue* q);
  191.  
  192. /* Used on videobuf-dvb */
  193. void *videobuf_queue_to_vmalloc (struct videobuf_queue* q,
  194.                  struct videobuf_buffer *buf);
  195.  
  196. void videobuf_queue_core_init(struct videobuf_queue *q,
  197.              struct videobuf_queue_ops *ops,
  198.              struct device *dev,
  199.              spinlock_t *irqlock,
  200.              enum v4l2_buf_type type,
  201.              enum v4l2_field field,
  202.              unsigned int msize,
  203.              void *priv,
  204.              struct videobuf_qtype_ops *int_ops);
  205. int  videobuf_queue_is_busy(struct videobuf_queue *q);
  206. void videobuf_queue_cancel(struct videobuf_queue *q);
  207.  
  208. enum v4l2_field videobuf_next_field(struct videobuf_queue *q);
  209. int videobuf_reqbufs(struct videobuf_queue *q,
  210.              struct v4l2_requestbuffers *req);
  211. int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b);
  212. int videobuf_qbuf(struct videobuf_queue *q,
  213.           struct v4l2_buffer *b);
  214. int videobuf_dqbuf(struct videobuf_queue *q,
  215.            struct v4l2_buffer *b, int nonblocking);
  216. #ifdef CONFIG_VIDEO_V4L1_COMPAT
  217. int videobuf_cgmbuf(struct videobuf_queue *q,
  218.             struct video_mbuf *mbuf, int count);
  219. #endif
  220. int videobuf_streamon(struct videobuf_queue *q);
  221. int videobuf_streamoff(struct videobuf_queue *q);
  222.  
  223. void videobuf_stop(struct videobuf_queue *q);
  224.  
  225. int videobuf_read_start(struct videobuf_queue *q);
  226. void videobuf_read_stop(struct videobuf_queue *q);
  227. ssize_t videobuf_read_stream(struct videobuf_queue *q,
  228.                  char __user *data, size_t count, loff_t *ppos,
  229.                  int vbihack, int nonblocking);
  230. ssize_t videobuf_read_one(struct videobuf_queue *q,
  231.               char __user *data, size_t count, loff_t *ppos,
  232.               int nonblocking);
  233. unsigned int videobuf_poll_stream(struct file *file,
  234.                   struct videobuf_queue *q,
  235.                   poll_table *wait);
  236.  
  237. int videobuf_mmap_setup(struct videobuf_queue *q,
  238.             unsigned int bcount, unsigned int bsize,
  239.             enum v4l2_memory memory);
  240. int __videobuf_mmap_setup(struct videobuf_queue *q,
  241.             unsigned int bcount, unsigned int bsize,
  242.             enum v4l2_memory memory);
  243. int videobuf_mmap_free(struct videobuf_queue *q);
  244. int videobuf_mmap_mapper(struct videobuf_queue *q,
  245.              struct vm_area_struct *vma);
  246.  
  247. #endif
  248.